Page({
    data: {
        type: '',
        taskId: '',
        modelUrls: null,
        prompt: '',
        artStyle: '',
        thumbnailUrl: '',
        progress: 0,
        status: 'PENDING',
        isProcessing: true,
        dataReady: false,
        imageLoaded: false,
        functionNames: {
            'text3d': '文本生成3D模型',
            'photo3d': '照片转3D模型'
        }
    },

    onLoad(options) {
        console.log('3D模型结果页面加载，参数：', options);

        try {
            // 解码URL参数
            const decodedOptions = {};
            Object.keys(options).forEach(key => {
                if (options[key]) {
                    try {
                        decodedOptions[key] = decodeURIComponent(options[key]);
                    } catch (e) {
                        console.warn(`解码参数 ${key} 失败:`, e);
                        decodedOptions[key] = options[key];
                    }
                }
            });

            // 验证必要参数
            if (!decodedOptions.type || !decodedOptions.task_id) {
                throw new Error('缺少必要参数');
            }

            // 设置页面数据
            this.setData({
                type: decodedOptions.type,
                taskId: decodedOptions.task_id,
                prompt: decodedOptions.prompt || '',
                artStyle: decodedOptions.art_style || 'realistic',
                status: 'PENDING',
                progress: 0,
                isProcessing: true,
                modelUrls: null,
                thumbnailUrl: ''
            });

            // 开始轮询任务状态
            this.startPollingTaskStatus();

        } catch (error) {
            console.error('页面加载失败:', error);
            this.setData({
                isProcessing: false
            });
            wx.showModal({
                title: '加载失败',
                content: '参数无效或已过期，请重新生成模型',
                showCancel: false,
                success: () => {
                    wx.navigateBack();
                }
            });
        }
    },

    startPollingTaskStatus() {
        if (!this.data.taskId) {
            console.error('任务ID无效');
            this.setData({
                isProcessing: false
            });
            return;
        }

        const checkStatus = () => {
            // 如果页面已经卸载，停止轮询
            if (!this.data.taskId) {
                return;
            }

            wx.request({
                // 改为你的后端服务IP和端口
                url: `http://127.0.0.1:1189/text-to-3d/${this.data.taskId}`,
                timeout: 120000, // 延长超时时间到60秒
                success: (res) => {
                    if (!this.data.taskId) return;

                    if (res.data) {
                        const { status, progress, model_urls, thumbnail_url, task_error } = res.data;

                        // 更新状态
                        this.setData({
                            status,
                            progress: progress || 0,
                            thumbnailUrl: thumbnail_url || ''
                        });

                        if (status === 'SUCCEEDED' && model_urls) {
                            // 只要状态是成功且有模型URL就立即显示
                            this.setData({
                                modelUrls: model_urls,
                                thumbnailUrl: thumbnail_url || '',
                                dataReady: true,
                                isProcessing: false // 直接设置处理完成
                            });

                            // 上传压缩图和.fbx文件到云存储
                            this.uploadToCloudStorage(thumbnail_url, model_urls);

                            // 保存3D模型作品到本地存储
                            const now = new Date();
                            const newWork = {
                                id: Date.now(),
                                type: this.data.type, // text3d 或 photo3d
                                image: thumbnail_url,
                                modelUrls: model_urls,
                                title: this.data.type === 'text3d'
                                    ? `描述: ${this.data.prompt}`
                                    : '照片转3D模型',
                                date: `${now.getFullYear()}-${(now.getMonth() + 1).toString().padStart(2, '0')}-${now.getDate().toString().padStart(2, '0')}`,
                                timestamp: now.getTime(),
                                prompt: this.data.prompt,
                                artStyle: this.data.artStyle
                            };

                            try {
                                const works = wx.getStorageSync('myWorks') || [];
                                works.unshift(newWork); // 将新作品添加到列表开头
                                wx.setStorageSync('myWorks', works);
                            } catch (e) {
                                console.error('保存3D模型作品到本地存储失败', e);
                            }
                        } else if (status === 'FAILED') {
                            this.setData({
                                isProcessing: false
                            });
                            wx.showModal({
                                title: '生成失败',
                                content: task_error?.message || '模型生成失败，请重试',
                                showCancel: false,
                                success: () => {
                                    this.cleanupAndNavigateBack();
                                }
                            });
                            return;
                        }

                        // 继续轮询，但缩短轮询间隔到5秒
                        if (this.data.taskId && status !== 'SUCCEEDED') {
                            setTimeout(checkStatus, 1000);
                        }
                    }
                },
                fail: (err) => {
                    if (!this.data.taskId) return;

                    console.error('查询任务状态失败：', err);
                    // 网络错误时不立即显示失败，继续尝试
                    if (this.data.taskId) {
                        setTimeout(checkStatus, 5000);
                    }
                }
            });
        };

        // 开始轮询
        checkStatus();
    },

    // 图片加载完成时触发
    onImageLoad() {
        // console.log('缩略图加载完成');
        this.setData({
            imageLoaded: true,
            isProcessing: false // 图片加载完成后隐藏加载遮罩
        });
    },

    // 清理资源并返回
    cleanupAndNavigateBack() {
        // 清理所有状态
        this.setData({
            isProcessing: false,
            taskId: '', // 清空taskId以停止轮询
            modelUrls: null
        });

        // 确保恢复tabBar显示
        const app = getApp();
        app.hideGlobalLoading();

        // 返回上一页
        const pages = getCurrentPages();
        if (pages.length > 1) {
            wx.navigateBack();
        } else {
            wx.switchTab({ url: '/pages/home/home' });
        }
    },

    onUnload() {
        // console.log('页面卸载，清理资源');
        // 清空taskId以停止轮询
        this.setData({
            taskId: '',
            isProcessing: false // 页面卸载时确保隐藏遮罩
        });

        // 确保恢复tabBar显示
        const app = getApp();
        app.hideGlobalLoading();
    },

    // 返回按钮的处理函数
    goBack() {
        if (this.data.isProcessing) {
            return;
        }
        this.cleanupAndNavigateBack();
    },

    // 修改下载按钮的处理函数为获取下载链接
    downloadModelFile() {
        if (this.data.isProcessing) {
            return;
        }

        // 获取模型下载链接
        const fbxUrl = this.data.modelUrls?.fbx;

        if (!fbxUrl) {
            wx.showToast({
                title: '模型地址无效',
                icon: 'error'
            });
            return;
        }

        // 判断是否为云存储fileID
        if (fbxUrl.startsWith('cloud://')) {
            // 云存储fileID，先获取临时URL
            wx.cloud.getTempFileURL({
                fileList: [fbxUrl],
                success: (res) => {
                    if (res.fileList && res.fileList[0] && res.fileList[0].tempFileURL) {
                        const downloadUrl = res.fileList[0].tempFileURL;
                        this.showDownloadLink(downloadUrl);
                    } else {
                        wx.showToast({
                            title: '获取下载链接失败',
                            icon: 'error'
                        });
                    }
                },
                fail: (err) => {
                    console.error('获取临时URL失败：', err);
                    wx.showToast({
                        title: '获取下载链接失败',
                        icon: 'error'
                    });
                }
            });
        } else {
            // 网络URL，直接显示下载链接
            this.showDownloadLink(fbxUrl);
        }
    },

    // 显示下载链接
    showDownloadLink(downloadUrl) {
        wx.showModal({
            title: '获取模型下载链接',
            content: '请复制以下链接到浏览器下载模型：\n\n' + downloadUrl,
            showCancel: false,
            confirmText: '复制链接',
            success: (res) => {
                if (res.confirm) {
                    wx.setClipboardData({
                        data: downloadUrl,
                        success: () => {
                            wx.showToast({
                                title: '链接已复制',
                                icon: 'success'
                            });
                        }
                    });
                }
            }
        });
    },

    // 分享
    onShareAppMessage() {
        const functionName = this.data.functionNames[this.data.type];
        return {
            title: `${functionName} - 生成工坊`,
            path: '/pages/home/home'
        };
    },

    onShareTimeline() {
        const imageUrl = this.data.thumbnailUrl;

        // 判断是否为云存储fileID
        if (imageUrl && imageUrl.startsWith('cloud://')) {
            // 云存储fileID，先获取临时URL再分享
            wx.cloud.getTempFileURL({
                fileList: [imageUrl],
                success: (res) => {
                    if (res.fileList && res.fileList[0] && res.fileList[0].tempFileURL) {
                        return {
                            title: `生成的3D模型：${this.data.prompt || '照片转3D模型'}`,
                            query: '',
                            imageUrl: res.fileList[0].tempFileURL
                        };
                    } else {
                        return {
                            title: `生成的3D模型：${this.data.prompt || '照片转3D模型'}`,
                            query: '',
                            imageUrl: ''
                        };
                    }
                },
                fail: (err) => {
                    console.error('获取临时URL失败：', err);
                    return {
                        title: `生成的3D模型：${this.data.prompt || '照片转3D模型'}`,
                        query: '',
                        imageUrl: ''
                    };
                }
            });
        } else {
            // 网络URL，直接分享
            return {
                title: `生成的3D模型：${this.data.prompt || '照片转3D模型'}`,
                query: '',
                imageUrl: imageUrl || ''
            };
        }
    },

    uploadToCloudStorage(thumbnailUrl, modelUrls) {
        const timestamp = (new Date()).valueOf();

        // 获取用户openId
        const app = getApp();
        const userOpenId = app.getUserOpenId();

        if (!userOpenId) {
            console.error('用户未登录，无法上传到云存储');
            return;
        }

        // 上传压缩图
        if (thumbnailUrl) {
            wx.downloadFile({
                url: thumbnailUrl,
                success: (downloadRes) => {
                    if (downloadRes.statusCode === 200) {
                        // 根据类型选择不同的压缩图存储路径和数据库type字段
                        let thumbnailCloudPath = '';
                        let dbType = '';

                        if (this.data.type === 'photo3d') {
                            thumbnailCloudPath = `spawnWorkshop/generate3DModelsFromPhotos/${timestamp}.png`;
                            dbType = 'photo_to_3d';
                        } else if (this.data.type === 'text3d') {
                            thumbnailCloudPath = `spawnWorkshop/textGeneration3DModels/${timestamp}.png`;
                            dbType = 'text_to_3d';
                        }

                        wx.cloud.uploadFile({
                            cloudPath: thumbnailCloudPath,
                            filePath: downloadRes.tempFilePath,
                            success: (uploadRes) => {
                                // console.log('压缩图上传到云存储成功:', uploadRes.fileID);

                                // 只存储缩略图的fileID到云数据库
                                const db = wx.cloud.database();
                                db.collection('spawnWorkshop').add({
                                    data: {
                                        userOpenId: userOpenId,
                                        path: uploadRes.fileID, // 只存储压缩图的fileID
                                        type: dbType
                                    }
                                }).then((dbRes) => {
                                    // console.log('缩略图数据存储到云数据库成功:', dbRes);
                                }).catch((dbErr) => {
                                    console.error('缩略图数据存储到云数据库失败:', dbErr);
                                });

                                // 更新本地存储中的压缩图URL为云存储fileID
                                this.setData({
                                    thumbnailUrl: uploadRes.fileID
                                });
                            },
                            fail: (uploadErr) => {
                                console.error('压缩图上传到云存储失败:', uploadErr);
                            }
                        });
                    }
                },
                fail: (downloadErr) => {
                    console.error('下载压缩图失败:', downloadErr);
                }
            });
        }

        // 上传.fbx文件到云存储（不存储到数据库）
        if (modelUrls && modelUrls.fbx) {
            wx.downloadFile({
                url: modelUrls.fbx,
                success: (downloadRes) => {
                    if (downloadRes.statusCode === 200) {
                        // .fbx文件统一存储到3DModels路径下
                        const fbxCloudPath = `spawnWorkshop/3DModels/${timestamp}.fbx`;

                        wx.cloud.uploadFile({
                            cloudPath: fbxCloudPath,
                            filePath: downloadRes.tempFilePath,
                            success: (uploadRes) => {
                                // console.log('FBX文件上传到云存储成功:', uploadRes.fileID);
                                // FBX文件上传成功，但不存储到数据库，只存储缩略图
                            },
                            fail: (uploadErr) => {
                                console.error('FBX文件上传到云存储失败:', uploadErr);
                            }
                        });
                    }
                },
                fail: (downloadErr) => {
                    console.error('下载FBX文件失败:', downloadErr);
                }
            });
        }
    }
});